/**
 * 日程提醒管理工具
 * 基于uni-app的本地推送消息实现日程提醒功能
 * 参考课程提醒系统实现
 */

class ScheduleReminder {
	constructor() {
		this.reminderPrefix = 'schedule_reminder_'
		this.defaultReminderMinutes = 30 // 默认提前30分钟提醒
		this.checkTimer = null // 实时检查定时器
		this.schedules = [] // 存储日程列表
	}
	
	/**
	 * 初始化提醒服务
	 */
	async init() {
		try {
			// 检查推送权限
			await this.checkPushPermission()
			console.log('日程提醒服务初始化成功')
		} catch (error) {
			console.error('日程提醒服务初始化失败:', error)
			throw error
		}
	}
	
	/**
	 * 检查推送权限
	 */
	async checkPushPermission() {
		return new Promise((resolve, reject) => {
			// #ifdef APP-PLUS
			const main = plus.android.runtimeMainActivity()
			const pkgName = main.getPackageName()
			const uid = main.getApplicationInfo().uid
			const NotificationManagerCompat = plus.android.importClass("androidx.core.app.NotificationManagerCompat")
			
			if (NotificationManagerCompat.from(main).areNotificationsEnabled()) {
				resolve(true)
			} else {
				// 引导用户开启通知权限
				uni.showModal({
					title: '需要通知权限',
					content: '为了及时提醒您的日程，请开启通知权限',
					confirmText: '去设置',
					success: (res) => {
						if (res.confirm) {
							const Intent = plus.android.importClass('android.content.Intent')
							const Settings = plus.android.importClass('android.provider.Settings')
							const intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
							const Uri = plus.android.importClass('android.net.Uri')
							intent.setData(Uri.parse("package:" + pkgName))
							main.startActivity(intent)
						}
						resolve(false)
					}
				})
			}
			// #endif
			
			// #ifndef APP-PLUS
			// 非APP平台，直接返回true
			resolve(true)
			// #endif
		})
	}
	
	/**
	 * 创建本地推送消息
	 * @param {Object} message 消息对象
	 */
	createLocalNotification(message) {
		return new Promise((resolve, reject) => {
			// #ifdef APP-PLUS
			const options = {
				cover: false,
				icon: '/static/logo.png',
				sound: 'system',
				title: message.title,
				content: message.content,
				when: message.when,
				category: 'schedule_reminder'
			}
			
			// 添加额外数据
			if (message.extra) {
				options.extra = message.extra
			}
			
			uni.createPushMessage({
				...options,
				success: (res) => {
					console.log('本地推送消息创建成功:', res)
					resolve(res)
				},
				fail: (error) => {
					console.error('本地推送消息创建失败:', error)
					reject(error)
				}
			})
			// #endif
			
			// #ifndef APP-PLUS
			// 非APP平台，模拟成功
			console.log('非APP平台，模拟推送消息创建成功:', message.title)
			resolve({ success: true })
			// #endif
		})
	}
	
	/**
	 * 清除所有日程提醒
	 */
	async clearAllReminders() {
		try {
			// 停止实时检查器
			this.stopRealTimeChecker()
			
			// 清空日程列表
			this.schedules = []
			
			// 清除已发送提醒的标记
			const storage = uni.getStorageInfoSync()
			storage.keys.forEach(key => {
				if (key.startsWith('schedule_sent_')) {
					uni.removeStorageSync(key)
				}
			})
			
			console.log('已清除实时日程提醒检查器和所有提醒标记')
		} catch (error) {
			console.error('清除日程提醒失败:', error)
		}
	}
	
	/**
	 * 获取提醒设置
	 */
	getReminderSettings() {
		const settings = uni.getStorageSync('schedule_reminder_settings') || {
			enabled: true,
			reminderMinutes: this.defaultReminderMinutes,
			soundEnabled: true,
			vibrationEnabled: true
		}
		return settings
	}
	
	/**
	 * 保存提醒设置
	 * @param {Object} settings 设置对象
	 */
	saveReminderSettings(settings) {
		uni.setStorageSync('schedule_reminder_settings', settings)
		console.log('日程提醒设置已保存:', settings)
	}
	
	/**
	 * 更新日程提醒（当日程发生变化时调用）
	 * @param {Array} schedules 新的日程列表
	 */
	async updateReminders(schedules) {
		const settings = this.getReminderSettings()
		if (!settings.enabled) {
			console.log('日程提醒已禁用，跳过更新')
			this.stopRealTimeChecker()
			return
		}
		
		try {
			// 过滤出需要提醒的日程（只有日程类型且启用提醒的）
			const reminderSchedules = schedules.filter(schedule => {
				return schedule.type !== 'task' && // 不是任务类型
					   schedule.endTime && // 有结束时间
					   !schedule.completed && // 未完成
					   schedule.reminder && // 有提醒配置
					   schedule.reminder.enabled // 提醒已启用
			})
			
			// 启动实时检查器
			this.startRealTimeChecker(reminderSchedules)
			console.log(`实时日程提醒检查器已启动，监控 ${reminderSchedules.length} 个日程`)
			return { success: true, count: reminderSchedules.length }
		} catch (error) {
			console.error('启动实时日程提醒检查器失败:', error)
			throw error
		}
	}
	
	/**
	 * 启动实时提醒检查器
	 * 每分钟检查一次是否有日程需要发送提醒
	 * @param {Array} schedules 日程列表
	 */
	startRealTimeChecker(schedules) {
		// 存储日程列表
		this.schedules = schedules
		
		// 清除之前的定时器
		if (this.checkTimer) {
			clearInterval(this.checkTimer)
		}
		
		// 每30秒检查一次，确保准确性
		this.checkTimer = setInterval(() => {
			this.checkAndSendReminders()
		}, 30 * 1000) // 30秒检查一次
		
		console.log(`实时日程提醒检查器已启动，监控 ${schedules.length} 个日程`)
	}
	
	/**
	 * 停止实时提醒检查器
	 */
	stopRealTimeChecker() {
		if (this.checkTimer) {
			clearInterval(this.checkTimer)
			this.checkTimer = null
			console.log('实时日程提醒检查器已停止')
		}
		// 清空日程列表
		this.schedules = []
	}
	
	/**
	 * 检查并发送提醒
	 */
	async checkAndSendReminders() {
		const now = new Date()
		const settings = this.getReminderSettings()
		
		if (!settings.enabled || !this.schedules || this.schedules.length === 0) {
			return
		}
		
		console.log(`[${now.toLocaleTimeString()}] 检查日程提醒`)
		
		for (const schedule of this.schedules) {
			if (!schedule.endTime || !schedule.title || schedule.completed) continue
			
			const scheduleEndTime = new Date(schedule.endTime)
			const timeDiffMinutes = Math.round((scheduleEndTime.getTime() - now.getTime()) / (1000 * 60))
			
			// 获取该日程的提醒时间设置，如果没有则使用默认值
			const reminderMinutes = schedule.reminder?.beforeMinutes || settings.reminderMinutes
			
			// 检查是否正好是提醒时间（误差±1分钟内）
			if (Math.abs(timeDiffMinutes - reminderMinutes) <= 1) {
				// 检查是否已经发送过这个提醒
				const reminderKey = `schedule_sent_${schedule.id}_${scheduleEndTime.toDateString()}`
				const alreadySent = uni.getStorageSync(reminderKey)
				
				if (!alreadySent) {
					console.log(`发送日程提醒: ${schedule.title} (${timeDiffMinutes}分钟后截止)`)
					await this.sendImmediateReminder(schedule, timeDiffMinutes)
					// 标记已发送
					uni.setStorageSync(reminderKey, true)
					
					// 设置过期时间（日程结束后清除标记）
					if (scheduleEndTime > now) {
						setTimeout(() => {
							uni.removeStorageSync(reminderKey)
						}, scheduleEndTime.getTime() - now.getTime() + 60 * 60 * 1000) // 日程结束1小时后清除
					}
				} else {
					console.log(`日程提醒已发送过: ${schedule.title}`)
				}
			}
		}
	}
	
	/**
	 * 立即发送提醒
	 * @param {Object} schedule 日程对象
	 * @param {Number} minutesUntilEnd 距离截止的分钟数
	 */
	async sendImmediateReminder(schedule, minutesUntilEnd) {
		try {
			const message = {
				id: 'immediate_schedule_' + schedule.id + '_' + Date.now(),
				title: '日程提醒',
				content: `${schedule.title} 将在 ${minutesUntilEnd} 分钟后截止`,
				when: new Date(), // 立即发送
				extra: {
					scheduleId: schedule.id,
					scheduleTitle: schedule.title,
					scheduleDescription: schedule.description || '',
					endTime: schedule.endTime,
					reminderMinutes: minutesUntilEnd,
					priority: schedule.priority || 'medium',
					tags: schedule.tags || []
				}
			}
			
			await this.createLocalNotification(message)
			console.log(`已发送实时日程提醒: ${schedule.title} (${minutesUntilEnd}分钟后截止)`)
		} catch (error) {
			console.error('发送实时日程提醒失败:', error)
		}
	}
	
	/**
	 * 获取即将到来的提醒列表
	 * @param {Number} hours 未来几小时内的提醒，默认24小时
	 */
	getUpcomingReminders(hours = 24) {
		const now = new Date()
		const future = new Date(now.getTime() + hours * 60 * 60 * 1000)
		const settings = this.getReminderSettings()
		
		if (!settings.enabled || !this.schedules) {
			return []
		}
		
		return this.schedules
			.filter(schedule => {
				if (!schedule.endTime || schedule.completed) return false
				
				const endTime = new Date(schedule.endTime)
				const reminderMinutes = schedule.reminder?.beforeMinutes || settings.reminderMinutes
				const reminderTime = new Date(endTime.getTime() - reminderMinutes * 60 * 1000)
				
				return reminderTime >= now && reminderTime <= future
			})
			.map(schedule => {
				const endTime = new Date(schedule.endTime)
				const reminderMinutes = schedule.reminder?.beforeMinutes || settings.reminderMinutes
				const reminderTime = new Date(endTime.getTime() - reminderMinutes * 60 * 1000)
				
				return {
					...schedule,
					reminderTime: reminderTime.toISOString(),
					minutesUntilReminder: Math.round((reminderTime.getTime() - now.getTime()) / (1000 * 60))
				}
			})
			.sort((a, b) => new Date(a.reminderTime) - new Date(b.reminderTime))
	}
}

// 创建单例实例
const scheduleReminder = new ScheduleReminder()

export default scheduleReminder 